/*!
 *      \file cannonfield.cpp
 *
 *      \brief Definitions for the CannonField class.
 *
 *      Copyright 2008 Anish Mangal <anishmangal2002@gmail.com>
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *      MA 02110-1301, USA.
 *
 * 		Author(s)	:	Anish Mangal
 * 		Email(s)	:	anishmangal2002@gmail.com
 * 		Code Rev.	:	0.1(alph)
 *		Project		:	cannon_camp
 * 		Date		:	2008-05-07-09.19 (IST)
 * 		Changelog	:	<log file>
 */

/****************************************************************************
**
** Copyright (C) 2005-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the example classes of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file.  Alternatively you may (at
** your option) use any later version of the GNU General Public
** License if such license has been publicly approved by Trolltech ASA
** (or its successors, if any) and the KDE Free Qt Foundation. In
** addition, as a special exception, Trolltech gives you certain
** additional rights. These rights are described in the Trolltech GPL
** Exception version 1.1, which can be found at
** http://www.trolltech.com/products/qt/gplexception/ and in the file
** GPL_EXCEPTION.txt in this package.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
** you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** In addition, as a special exception, Trolltech, as the sole
** copyright holder for Qt Designer, grants users of the Qt/Eclipse
** Integration plug-in the right for the Qt/Eclipse Integration to
** link to functionality provided by Qt Designer and its related
** libraries.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
** granted herein.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include <QDateTime>
#include <QPaintEvent>
#include <QPainter>
#include <QTimer>
#include <QTime>
#include <iostream>

#include <math.h>
#include <stdlib.h>

#include "cannonfield.h"

int CannonField::seed = 0;

CannonField::CannonField(QWidget *parent)
    : QWidget(parent)
{
    currentAngle 	= 45;
    currentForce 	= 0;
    timerCount 		= 0;
	shootAngle 		= 0;
    shootForce 		= 0;
    gameEnded 		= false;
    barrelPressed 	= false;
    target 			= NULL;

    QTime midnight(0, 0, 0);
    seed = midnight.msecsTo(QTime::currentTime());
    setPalette(QPalette(QColor(250, 250, 200)));
    setAutoFillBackground(true);

	updateWind();
    autoShootTimer	= new QTimer(this);
    sysTimer		= new QTimer(this);
    sysTimer->start(50);
	connect(sysTimer, SIGNAL(timeout()), this, SLOT(updateTargetPos()));
    connect(autoShootTimer, SIGNAL(timeout()), this, SLOT(moveShot()));

    newTarget();
}

void CannonField::updateWind()
{
    QTime midnight(0, 0, 0);
    qsrand(midnight.secsTo(QTime::currentTime()));

    currentWind = (qrand() % 21) - 10;
    emit windChanged(currentWind);
}

void CannonField::setAngle(int angle)
{
    if (angle < 5)
        angle = 5;
    if (angle > 70)
        angle = 70;
    if (currentAngle == angle)
        return;
    currentAngle = angle;
    update(cannonRect());
    emit angleChanged(currentAngle);
}

void CannonField::setForce(int force)
{
    if (force < 0)
        force = 0;
    if (currentForce == force)
        return;
    currentForce = force;
    emit forceChanged(currentForce);
}

void CannonField::shoot()
{
    if (isShooting())
        return;
    timerCount = 0;
    shootAngle = currentAngle;
    shootForce = currentForce;
    autoShootTimer->start(5);
    emit canShoot(false);
}

void CannonField::newTarget()
{
	if(target == NULL)
		addTarget();
	else
	{
		while(target != NULL)
			deleteTarget();
		addTarget();
	}
}

void CannonField::addTarget()
{
    //std::cout<<"Called\n";
    seed++;
    if(target == NULL)
    {
    	qsrand(seed);
    	target = new node;
    	target->point = QPoint(200 + qrand() % 300, 75 + qrand() % 175);
    	target->motionType = qrand() % 4;
    	target->counter = qrand() % 60;
    	target->increment = pow(-1,qrand() % 4);
    	target->next  = NULL;
    }
	else
	{
		qsrand(seed);
		node * tNode = target;
		node * temp = new node;
		while(tNode->next != NULL)
			tNode = tNode->next;
		temp->point = QPoint(200 + qrand() % 300, 75 + qrand() % 175);
		temp->motionType = qrand() % 4;
		temp->counter = qrand() % 60;
		temp->increment = pow(-1,qrand() % 4);
		temp->next = NULL;
		tNode->next = temp;
	}
    update();
}

void CannonField::deleteTarget()
{
	node * tNode = target;
	if(tNode == NULL)
		return;
	else
	{
		target = tNode->next;
		delete tNode;
		return;
	}
}

void CannonField::updateTargetPos()
{
	node * tNode = target;

	if(tNode == NULL)
		;
	else
	{
		while(tNode != NULL)
		{
			tNode->counter++;

			if(tNode->counter >= 60)
			{
				tNode->increment = -tNode->increment;
				tNode->counter = 0;
			}

			switch(tNode->motionType)
			{
				case 	0:	break;
				case	1:	tNode->point.setX(tNode->point.x() + tNode->increment);
							break;
				case	2:	tNode->point.setY(tNode->point.y() + tNode->increment);
							break;
				case	3:	tNode->point.setX(tNode->point.x() + tNode->increment);
							tNode->point.setY(tNode->point.y() - tNode->increment);
							break;
				default	 :	break;
			}

			//std::cout<<tNode->point.x()<<"\t"<<tNode->point.x()<<std::endl;
			tNode = tNode->next;
		}
	}
	update();
}

void CannonField::setGameOver()
{
    if (gameEnded)
        return;
    if (isShooting())
        autoShootTimer->stop();
    gameEnded = true;
    update();
}

void CannonField::restartGame()
{
    if (isShooting())
        autoShootTimer->stop();
    gameEnded = false;
    update();
    emit canShoot(true);
}

void CannonField::moveShot()
{
    QRegion region = shotRect();
    ++timerCount;

    QRect shotR = shotRect();

	node * tNode = target;
	while(tNode != NULL)
	{
		if (shotR.intersects(targetRect(tNode->point)))
		{
			autoShootTimer->stop();
			emit hit(tNode->point);
			emit canShoot(true);
			updateWind();
			break;
		}
		tNode = tNode->next;
	}
    if (shotR.x() > width() || shotR.y() > height() ||
    	shotR.intersects(barrierRect()))
    {
        autoShootTimer->stop();
        emit missed();
        emit canShoot(true);
        updateWind();
    }
    else
    {
        region = region.unite(shotR);
    }
    update(region);
}

void CannonField::mousePressEvent(QMouseEvent *event)
{
	if (event->button() != Qt::LeftButton)
		return;
	if (barrelHit(event->pos()))
		barrelPressed = true;
}

void CannonField::mouseMoveEvent(QMouseEvent *event)
{
	if (!barrelPressed)
		return;

	QPoint pos = event->pos();

	if (pos.x() <= 0)
		pos.setX(1);

	if (pos.y() >= height())
		pos.setY(height() - 1);

	double rad = atan(((double)rect().bottom() - pos.y()) / pos.x());
	setAngle(qRound(rad * 180 / 3.14159265));
}

void CannonField::mouseReleaseEvent(QMouseEvent *event)
{
	if (event->button() == Qt::LeftButton)
		barrelPressed = false;
}

void CannonField::paintEvent(QPaintEvent * /* event */)
{
    QPainter painter(this);

    if (gameEnded)
    {
        painter.setPen(Qt::black);
        painter.setFont(QFont("Courier", 48, QFont::Bold));
        painter.drawText(rect(), Qt::AlignHCenter|Qt::AlignTop, tr("Game Over"));
        painter.setFont(QFont("Courier", 10, QFont::Bold));
        painter.drawText(rect(), Qt::AlignCenter,
        tr("Author: Anish Mangal\nRef: Qt4 Tutorials\nThanks: Free s/w Community\n"));
    }
    paintCannon(painter);
    paintBarrier(painter);

    if (isShooting())
        paintShot(painter);

    if (!gameEnded)
        paintTarget(painter);
}

void CannonField::paintShot(QPainter &painter)
{
    painter.setPen(Qt::NoPen);
    painter.setBrush(Qt::black);
    painter.drawRect(shotRect());
}

void CannonField::paintBadTarget(QPainter &painter)
{
    painter.setPen(Qt::black);
    painter.setBrush(Qt::red);
    painter.setBrush(Qt::Dense5Pattern);

    node * tNode = target;
    while(tNode != NULL)
    {
	    painter.drawRect(targetRect(tNode->point));
	   // std::cout<<"Drawing at "<<tNode->point.x()<<" , "
	   // 		 <<tNode->point.y()<<"\n";
	    tNode = tNode->next;
    }
}

void CannonField::paintTarget(QPainter &painter)
{
    painter.setPen(Qt::black);
    painter.setBrush(Qt::red);

    node * tNode = target;
    while(tNode != NULL)
    {
	    painter.drawRect(targetRect(tNode->point));
	   // std::cout<<"Drawing at "<<tNode->point.x()<<" , "
	   // 		 <<tNode->point.y()<<"\n";
	    tNode = tNode->next;
    }
}

const QRect barrelRect(30, -5, 20, 10);

void CannonField::paintBarrier(QPainter &painter)
{
	painter.setPen(Qt::black);
	painter.setBrush(Qt::yellow);
	painter.drawRect(barrierRect());
}

void CannonField::paintCannon(QPainter &painter)
{
    //painter.setPen(Qt::NoPen);
    painter.setBrush(Qt::blue);

    painter.save();
    painter.translate(0, height());
    painter.drawPie(QRect(-35, -35, 70, 70), 0, 90 * 16);
    painter.rotate(-currentAngle);
    painter.drawRect(barrelRect);
    painter.restore();
}

QRect CannonField::cannonRect() const
{
    QRect result(0, 0, 50, 50);
    result.moveBottomLeft(rect().bottomLeft());
    return result;
}

QRect CannonField::shotRect() const
{
    const double gravity = 3;

    double time = timerCount / 20.0;
    double velocity = shootForce;
    double radians = shootAngle * 3.14159265 / 180;

    double velx = velocity * cos(radians) + double(currentWind) / 2;
    double vely = velocity * sin(radians);
    double x0 = (barrelRect.right() + 5) * cos(radians);
    double y0 = (barrelRect.right() + 5) * sin(radians);
    double x = x0 + velx * time;
    double y = y0 + vely * time - 0.5 * gravity * time * time;

    QRect result(0, 0, 6, 6);
    result.moveCenter(QPoint(qRound(x), height() - 1 - qRound(y)));
    return result;
}

QRect CannonField::targetRect(QPoint p) const
{
    QRect result(0, 0, 20, 10);
    result.moveCenter(p);
    //std::cout<<p.x()<<"\t"<<p.y()<<"\n";
    return result;
}

QRect CannonField::barrierRect() const
{
	return QRect(145, height() - 100, 15, 99);
}

bool CannonField::barrelHit(const QPoint &pos) const
{
	QMatrix matrix;
	matrix.translate(0, height());
	matrix.rotate(-currentAngle);
	matrix = matrix.inverted();
	return barrelRect.contains(matrix.map(pos));
}

bool CannonField::isShooting() const
{
    return autoShootTimer->isActive();
}

QSize CannonField::sizeHint() const
{
	return QSize(400, 300);
}
